1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
#include "gamestate.h"
#include "game.h"
#include "astleaf.h"
#include "astleafliteral.h"
#include <bu/sio.h>
using namespace Bu;
GameState::GameState( Game *pGame ) :
pGame( pGame )
{
}
GameState::~GameState()
{
}
void GameState::parse( class AstBranch *pAst )
{
if( pAst->getType() != AstNode::tScope )
throw Bu::ExceptionBase("Nope, nothing doing, you can't parse a non-scope AstBranch.");
lsLocal.push( new Scope() );
parse( pAst->getNodeList() );
delete lsLocal.peekPop();
}
void GameState::init()
{
Variable vStart = pGame->getParam("start");
if( vStart.getType() != Variable::tSituation )
throw Bu::ExceptionBase("game.start is not set to a situation name.");
gotoSituation( vStart.getString() );
}
void GameState::gotoSituation( const Bu::String &sName )
{
Situation *pSit = pGame->getSituation( sName );
sCurSituation = sName;
if( !hsSituation.has( sName ) )
{
hsSituation.insert( sName, new Scope() );
pSit->exec( *this, Situation::modeSetup );
}
pSit->exec( *this, Situation::modeEnter );
}
void GameState::callFunction( const Bu::String &sName )
{
pGame->getFunction( sName )->call( *this );
}
Variable GameState::getVariable( const Bu::String &sName, ScopeId id )
{
switch( id )
{
case sidLocal:
return lsLocal.peek()->get( sName );
case sidGlobal:
return sGlobal.get( sName );
case sidPlayer:
return sPlayer.get( sName );
case sidSituation:
return hsSituation.get( sCurSituation )->get( sName );
}
throw Bu::ExceptionBase("Really bad scopeid passed into getVariable");
}
void GameState::setVariable( const Bu::String &sName, const Variable &v,
ScopeId id )
{
switch( id )
{
case sidLocal:
lsLocal.peek()->insert( sName, v );
return;
case sidGlobal:
sGlobal.insert( sName, v );
return;
case sidPlayer:
sPlayer.insert( sName, v );
return;
case sidSituation:
hsSituation.get( sCurSituation )->insert( sName, v );
return;
}
throw Bu::ExceptionBase("Really bad scopeid passed into setVariable");
}
Variable GameState::deref( const Variable &src )
{
if( src.getType() == Variable::tVariable )
return getVariable( src.getString() );
return src;
}
Variable GameState::popDeref()
{
Variable v = lStack.peekPop();
if( v.getType() == Variable::tVariable )
return getVariable( v.getString() );
return v;
}
void GameState::parse( const AstBranch::NodeList &lCode )
{
for( AstBranch::NodeList::const_iterator i = lCode.begin(); i; i++ )
{
sio << "Stack: " << lStack << sio.nl;
switch( (*i)->getType() )
{
// tLeaf
case AstNode::tNot:
case AstNode::tComp:
case AstNode::tCompGt:
case AstNode::tCompLt:
case AstNode::tCompGtEq:
case AstNode::tCompLtEq:
case AstNode::tStore:
{
Variable y = popDeref();
Variable dst = pop();
setVariable( dst.getString(), y );
}
break;
case AstNode::tAnd:
case AstNode::tOr:
case AstNode::tPlus:
{
Variable y = popDeref();
Variable x = popDeref();
lStack.push( x + y );
}
break;
case AstNode::tMinus:
case AstNode::tDivide:
case AstNode::tMultiply:
case AstNode::tPlusStore:
case AstNode::tMinusStore:
case AstNode::tDivideStore:
case AstNode::tMultiplyStore:
case AstNode::tNegate:
case AstNode::tIn:
// tLeafLiteral
case AstNode::tVarName:
case AstNode::tLiteral:
lStack.push( dynamic_cast<const AstLeafLiteral *>(*i)->getValue() );
break;
case AstNode::tFuncCall:
callFunction(
dynamic_cast<const AstLeafLiteral *>(*i)
->getValue().getString()
);
break;
// tBranch
case AstNode::tScope:
case AstNode::tIf:
case AstNode::tForEach:
case AstNode::tWhile:
break;
}
}
}
|
